home *** CD-ROM | disk | FTP | other *** search
/ Scene 96 / Scene 96 International Edition (Zyklop Software) (Disc 2) (1997).iso / misc / coding / midas060 / samples / midpnt / regtest.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-22  |  6.0 KB  |  234 lines
  1. #include <stdio.h>
  2. #define WIN32_LEAN_AND_MEAN
  3. #include <windows.h>
  4.  
  5.  
  6. void Error(char *msg)
  7. {
  8.     printf("Error: %s\n", msg);
  9. }
  10.  
  11.  
  12. class Registry
  13. {
  14.     HKEY        key;
  15. public:
  16.     Registry();
  17.     ~Registry();
  18.     int KeyExists(const char *name);
  19.     void CreateKey(const char *name);
  20.     void OpenKey(const char *name);
  21.     void Value(const char *name, void *data, DWORD *dataLength,
  22.         DWORD bufferLength, DWORD *dataType);
  23.     void ValueString(const char *name, const char *defaultData, char *dest,
  24.         int bufferLength);
  25.     void WriteString(const char *name, const char *string);
  26.     DWORD ValueDWORD(const char *name, DWORD defaultData);
  27.     void WriteDWORD(const char *name, const DWORD data);
  28. };
  29.  
  30.  
  31. Registry::Registry()
  32. {
  33. }
  34.  
  35.  
  36. Registry::~Registry()
  37. {
  38. }
  39.  
  40.  
  41. int Registry::KeyExists(const char *name)
  42. {
  43.     LONG        err;
  44.  
  45.     err = RegOpenKeyEx(HKEY_CURRENT_USER, name, 0, KEY_ALL_ACCESS, &key);
  46.     if ( err != ERROR_SUCCESS )
  47.         return 0;
  48.     return 1;
  49. }
  50.  
  51.  
  52. void Registry::CreateKey(const char *name)
  53. {
  54.     LONG        err;
  55.     DWORD       createStatus;
  56.  
  57.     err = RegCreateKeyEx(HKEY_CURRENT_USER, name, 0, NULL,
  58.         REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &createStatus);
  59.     if ( err != ERROR_SUCCESS )
  60.         Error("Registry key creation failed");
  61. }
  62.  
  63.  
  64.  
  65. void Registry::OpenKey(const char *name)
  66. {
  67.     LONG        err;
  68.  
  69.     err = RegOpenKeyEx(HKEY_CURRENT_USER, name, 0, KEY_ALL_ACCESS, &key);
  70.     if ( err != ERROR_SUCCESS )
  71.         Error("Registry key opening failed");
  72. }
  73.  
  74.  
  75. void Registry::Value(const char *name, void *data, DWORD *dataLength, DWORD
  76.     bufferLength, DWORD *dataType)
  77. {
  78.     LONG        err;
  79.     DWORD       len;
  80.     DWORD       type;
  81.  
  82.     len = bufferLength;
  83.     err = RegQueryValueEx(key, (LPSTR) name, 0, &type, (LPBYTE) data,
  84.         &len);
  85.     if ( err != ERROR_SUCCESS )
  86.     {
  87.         len = *dataLength;
  88.         type = *dataType;
  89.         err = RegSetValueEx(key, (LPSTR) name, 0, type,
  90.             (CONST BYTE*) data, len);
  91.         if ( err != ERROR_SUCCESS )
  92.             Error("Registry value creation failed");
  93.     }
  94.  
  95.     *dataLength = len;
  96.     *dataType = type;
  97. }
  98.  
  99.  
  100. void Registry::ValueString(const char *name, const char *defaultData,
  101.     char *dest, int bufferLength)
  102. {
  103.     DWORD       len;
  104.     DWORD       type = REG_SZ;
  105.  
  106.     if ( bufferLength < (strlen(defaultData) + 1) )
  107.         Error("Registry::ValueString() - too long default");
  108.  
  109.     strcpy(dest, defaultData);
  110.     len = strlen(dest) + 1;
  111.  
  112.     Value(name, (void*) dest, &len, bufferLength, &type);
  113.  
  114.     if ( type != REG_SZ )
  115.         Error("Registry::ValueString() - illegal value type");
  116. }
  117.  
  118.  
  119. void Registry::WriteString(const char *name, const char *string)
  120. {
  121.     DWORD       err;
  122.  
  123.     err = RegSetValueEx(key, (LPSTR) name, 0, REG_SZ, (CONST BYTE*) string,
  124.         strlen(string)+1);
  125.     if ( err != ERROR_SUCCESS )
  126.         Error("Registry::WriteString(): value creation failed");
  127. }
  128.  
  129.  
  130. DWORD Registry::ValueDWORD(const char *name, DWORD defaultData)
  131. {
  132.     DWORD       len, type, buf;
  133.  
  134.     buf = defaultData;
  135.     len = sizeof(DWORD);
  136.     type = REG_DWORD;
  137.  
  138.     Value(name, (void*) &buf, &len, sizeof(DWORD), &type);
  139.  
  140.     if ( type != REG_DWORD )
  141.         Error("Registy::ValueDWORD() - illegal value type");
  142.  
  143.     return buf;
  144. }
  145.  
  146.  
  147.  
  148. void Registry::WriteDWORD(const char *name, const DWORD data)
  149. {
  150.     DWORD       err;
  151.     DWORD       buf = data;
  152.  
  153.     err = RegSetValueEx(key, (LPSTR) name, 0, REG_DWORD, (CONST BYTE*) &buf,
  154.         sizeof(DWORD));
  155.     if ( err != ERROR_SUCCESS )
  156.         Error("Registry::WriteDWORD(): value creation failed");
  157. }
  158.  
  159.  
  160.  
  161.  
  162. int main(void)
  163. {
  164.     char        name[MAX_PATH];
  165.     DWORD       nameLen = MAX_PATH;
  166.     DWORD       valType;
  167.     Registry    reg;
  168.  
  169.     if ( !reg.KeyExists("Software\\Sahara Surfers\\MidpNT") )
  170.         reg.CreateKey("Software\\Sahara Surfers\\MidpNT");
  171.     else
  172.         reg.OpenKey("Software\\Sahara Surfers\\MidpNT");
  173.  
  174.     strcpy(name, "c:\\haa\\huujamaaa");
  175.     nameLen = strlen(name)+1;
  176.     valType = REG_SZ;
  177.     reg.Value("DefaultDirectory", name, &nameLen, MAX_PATH, &valType);
  178.     printf("Data: \"%s\", len %lu, type %lu\n", name, nameLen, valType);
  179.  
  180.     reg.ValueString("TestString", "DefaultString", name, MAX_PATH);
  181.     printf("Got string: \"%s\"\n", name);
  182.  
  183.     printf("Got DWORD: %lu\n", reg.ValueDWORD("KalanArvo", 17));
  184.     printf("Lahna Got DWORD: %lu\n", reg.ValueDWORD("LahnanArvo", 17));
  185.     reg.WriteDWORD("LahnanArvo", 42);
  186.  
  187.     reg.ValueString("LahnaStr", "Lahna", name, MAX_PATH);
  188.     printf("Lahna Got string: \"%s\"\n", name);
  189.     reg.WriteString("LahnaStr", "Hauki");
  190.  
  191. /*
  192.     err = RegOpenKeyEx(HKEY_CURRENT_USER,
  193.         "Software\\Sahara Surfers\\MidpNT", 0, KEY_ALL_ACCESS, &key);
  194.     if ( err != ERROR_SUCCESS )
  195.     {
  196.         printf("Couldn't open key, will create it\n");
  197.         err = RegCreateKeyEx(HKEY_CURRENT_USER,
  198.             "Software\\Sahara Surfers\\MidpNT", 0, NULL,
  199.             REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key,
  200.                 &createStatus);
  201.         if ( err != ERROR_SUCCESS )
  202.         {
  203.             printf("Couldn't create key: %li\n", err);
  204.             return 1;
  205.         }
  206.         if ( createStatus == REG_CREATED_NEW_KEY )
  207.             printf("Created new key\n");
  208.         else
  209.             printf("Opened old key (?!?)\n");
  210.     }
  211.     printf("We have a key: %08X\n", (unsigned) key);
  212.  
  213.     err = RegQueryValueEx(key, "DefaultDirectory", 0, &valType,
  214.         (LPBYTE) name, &nameLen);
  215.     if ( err != ERROR_SUCCESS )
  216.     {
  217.         printf("Couldn't query value, will create it\n");
  218.         err = RegSetValueEx(key, "DefaultDirectory", 0, REG_SZ,
  219.             (CONST BYTE*) "q:\\kala\\dirikkkka", 18);
  220.         if ( err != ERROR_SUCCESS )
  221.         {
  222.             printf("Creation failed: %li\n", err);
  223.             return 2;
  224.         }
  225.     }
  226.     else
  227.     {
  228.         printf("Got value: \"%s\", type %li, len %li\n", name, valType,
  229.             nameLen);
  230.     }
  231. */
  232.  
  233.     return 0;
  234. }